home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / logging / handlers.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  30.4 KB  |  1,031 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """
  5. Additional handlers for the logging package for Python. The core package is
  6. based on PEP 282 and comments thereto in comp.lang.python, and influenced by
  7. Apache's log4j system.
  8.  
  9. Should work under Python versions >= 1.5.2, except that source line
  10. information is not available unless 'sys._getframe()' is.
  11.  
  12. Copyright (C) 2001-2004 Vinay Sajip. All Rights Reserved.
  13.  
  14. To use, simply 'import logging' and log away!
  15. """
  16. import sys
  17. import logging
  18. import socket
  19. import types
  20. import os
  21. import string
  22. import cPickle
  23. import struct
  24. import time
  25. import glob
  26.  
  27. try:
  28.     import codecs
  29. except ImportError:
  30.     codecs = None
  31.  
  32. DEFAULT_TCP_LOGGING_PORT = 9020
  33. DEFAULT_UDP_LOGGING_PORT = 9021
  34. DEFAULT_HTTP_LOGGING_PORT = 9022
  35. DEFAULT_SOAP_LOGGING_PORT = 9023
  36. SYSLOG_UDP_PORT = 514
  37.  
  38. class BaseRotatingHandler(logging.FileHandler):
  39.     '''
  40.     Base class for handlers that rotate log files at a certain point.
  41.     Not meant to be instantiated directly.  Instead, use RotatingFileHandler
  42.     or TimedRotatingFileHandler.
  43.     '''
  44.     
  45.     def __init__(self, filename, mode, encoding = None):
  46.         '''
  47.         Use the specified filename for streamed logging
  48.         '''
  49.         if codecs is None:
  50.             encoding = None
  51.         
  52.         logging.FileHandler.__init__(self, filename, mode, encoding)
  53.         self.mode = mode
  54.         self.encoding = encoding
  55.  
  56.     
  57.     def emit(self, record):
  58.         '''
  59.         Emit a record.
  60.  
  61.         Output the record to the file, catering for rollover as described
  62.         in doRollover().
  63.         '''
  64.         
  65.         try:
  66.             if self.shouldRollover(record):
  67.                 self.doRollover()
  68.             
  69.             logging.FileHandler.emit(self, record)
  70.         except:
  71.             self.handleError(record)
  72.  
  73.  
  74.  
  75.  
  76. class RotatingFileHandler(BaseRotatingHandler):
  77.     '''
  78.     Handler for logging to a set of files, which switches from one file
  79.     to the next when the current file reaches a certain size.
  80.     '''
  81.     
  82.     def __init__(self, filename, mode = 'a', maxBytes = 0, backupCount = 0, encoding = None):
  83.         '''
  84.         Open the specified file and use it as the stream for logging.
  85.  
  86.         By default, the file grows indefinitely. You can specify particular
  87.         values of maxBytes and backupCount to allow the file to rollover at
  88.         a predetermined size.
  89.  
  90.         Rollover occurs whenever the current log file is nearly maxBytes in
  91.         length. If backupCount is >= 1, the system will successively create
  92.         new files with the same pathname as the base file, but with extensions
  93.         ".1", ".2" etc. appended to it. For example, with a backupCount of 5
  94.         and a base file name of "app.log", you would get "app.log",
  95.         "app.log.1", "app.log.2", ... through to "app.log.5". The file being
  96.         written to is always "app.log" - when it gets filled up, it is closed
  97.         and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
  98.         exist, then they are renamed to "app.log.2", "app.log.3" etc.
  99.         respectively.
  100.  
  101.         If maxBytes is zero, rollover never occurs.
  102.         '''
  103.         if maxBytes > 0:
  104.             mode = 'a'
  105.         
  106.         BaseRotatingHandler.__init__(self, filename, mode, encoding)
  107.         self.maxBytes = maxBytes
  108.         self.backupCount = backupCount
  109.  
  110.     
  111.     def doRollover(self):
  112.         '''
  113.         Do a rollover, as described in __init__().
  114.         '''
  115.         self.stream.close()
  116.         if self.backupCount > 0:
  117.             for i in range(self.backupCount - 1, 0, -1):
  118.                 sfn = '%s.%d' % (self.baseFilename, i)
  119.                 dfn = '%s.%d' % (self.baseFilename, i + 1)
  120.                 if os.path.exists(sfn):
  121.                     if os.path.exists(dfn):
  122.                         os.remove(dfn)
  123.                     
  124.                     os.rename(sfn, dfn)
  125.                     continue
  126.             
  127.             dfn = self.baseFilename + '.1'
  128.             if os.path.exists(dfn):
  129.                 os.remove(dfn)
  130.             
  131.             os.rename(self.baseFilename, dfn)
  132.         
  133.         if self.encoding:
  134.             self.stream = codecs.open(self.baseFilename, 'w', self.encoding)
  135.         else:
  136.             self.stream = open(self.baseFilename, 'w')
  137.  
  138.     
  139.     def shouldRollover(self, record):
  140.         '''
  141.         Determine if rollover should occur.
  142.  
  143.         Basically, see if the supplied record would cause the file to exceed
  144.         the size limit we have.
  145.         '''
  146.         if self.maxBytes > 0:
  147.             msg = '%s\n' % self.format(record)
  148.             self.stream.seek(0, 2)
  149.             if self.stream.tell() + len(msg) >= self.maxBytes:
  150.                 return 1
  151.             
  152.         
  153.         return 0
  154.  
  155.  
  156.  
  157. class TimedRotatingFileHandler(BaseRotatingHandler):
  158.     '''
  159.     Handler for logging to a file, rotating the log file at certain timed
  160.     intervals.
  161.  
  162.     If backupCount is > 0, when rollover is done, no more than backupCount
  163.     files are kept - the oldest ones are deleted.
  164.     '''
  165.     
  166.     def __init__(self, filename, when = 'h', interval = 1, backupCount = 0, encoding = None):
  167.         BaseRotatingHandler.__init__(self, filename, 'a', encoding)
  168.         self.when = string.upper(when)
  169.         self.backupCount = backupCount
  170.         currentTime = int(time.time())
  171.         if self.when == 'S':
  172.             self.interval = 1
  173.             self.suffix = '%Y-%m-%d_%H-%M-%S'
  174.         elif self.when == 'M':
  175.             self.interval = 60
  176.             self.suffix = '%Y-%m-%d_%H-%M'
  177.         elif self.when == 'H':
  178.             self.interval = 60 * 60
  179.             self.suffix = '%Y-%m-%d_%H'
  180.         elif self.when == 'D' or self.when == 'MIDNIGHT':
  181.             self.interval = 60 * 60 * 24
  182.             self.suffix = '%Y-%m-%d'
  183.         elif self.when.startswith('W'):
  184.             self.interval = 60 * 60 * 24 * 7
  185.             if len(self.when) != 2:
  186.                 raise ValueError('You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s' % self.when)
  187.             
  188.             if self.when[1] < '0' or self.when[1] > '6':
  189.                 raise ValueError('Invalid day specified for weekly rollover: %s' % self.when)
  190.             
  191.             self.dayOfWeek = int(self.when[1])
  192.             self.suffix = '%Y-%m-%d'
  193.         else:
  194.             raise ValueError('Invalid rollover interval specified: %s' % self.when)
  195.         self.interval = self.interval * interval
  196.         self.rolloverAt = currentTime + self.interval
  197.         if self.when == 'MIDNIGHT' or self.when.startswith('W'):
  198.             t = time.localtime(currentTime)
  199.             currentHour = t[3]
  200.             currentMinute = t[4]
  201.             currentSecond = t[5]
  202.             r = (24 - currentHour) * 60 * 60
  203.             r = r + (59 - currentMinute) * 60
  204.             r = r + (59 - currentSecond)
  205.             self.rolloverAt = currentTime + r
  206.             if when.startswith('W'):
  207.                 day = t[6]
  208.                 if day > self.dayOfWeek:
  209.                     daysToWait = day - self.dayOfWeek - 1
  210.                     self.rolloverAt = self.rolloverAt + daysToWait * 60 * 60 * 24
  211.                 
  212.                 if day < self.dayOfWeek:
  213.                     daysToWait = (6 - self.dayOfWeek) + day
  214.                     self.rolloverAt = self.rolloverAt + daysToWait * 60 * 60 * 24
  215.                 
  216.             
  217.         
  218.  
  219.     
  220.     def shouldRollover(self, record):
  221.         '''
  222.         Determine if rollover should occur
  223.  
  224.         record is not used, as we are just comparing times, but it is needed so
  225.         the method siguratures are the same
  226.         '''
  227.         t = int(time.time())
  228.         if t >= self.rolloverAt:
  229.             return 1
  230.         
  231.         return 0
  232.  
  233.     
  234.     def doRollover(self):
  235.         '''
  236.         do a rollover; in this case, a date/time stamp is appended to the filename
  237.         when the rollover happens.  However, you want the file to be named for the
  238.         start of the interval, not the current time.  If there is a backup count,
  239.         then we have to get a list of matching filenames, sort them and remove
  240.         the one with the oldest suffix.
  241.         '''
  242.         self.stream.close()
  243.         t = self.rolloverAt - self.interval
  244.         timeTuple = time.localtime(t)
  245.         dfn = self.baseFilename + '.' + time.strftime(self.suffix, timeTuple)
  246.         if os.path.exists(dfn):
  247.             os.remove(dfn)
  248.         
  249.         os.rename(self.baseFilename, dfn)
  250.         if self.backupCount > 0:
  251.             s = glob.glob(self.baseFilename + '.20*')
  252.             if len(s) > self.backupCount:
  253.                 s.sort()
  254.                 os.remove(s[0])
  255.             
  256.         
  257.         if self.encoding:
  258.             self.stream = codecs.open(self.baseFilename, 'w', self.encoding)
  259.         else:
  260.             self.stream = open(self.baseFilename, 'w')
  261.         self.rolloverAt = int(time.time()) + self.interval
  262.  
  263.  
  264.  
  265. class SocketHandler(logging.Handler):
  266.     """
  267.     A handler class which writes logging records, in pickle format, to
  268.     a streaming socket. The socket is kept open across logging calls.
  269.     If the peer resets it, an attempt is made to reconnect on the next call.
  270.     The pickle which is sent is that of the LogRecord's attribute dictionary
  271.     (__dict__), so that the receiver does not need to have the logging module
  272.     installed in order to process the logging event.
  273.  
  274.     To unpickle the record at the receiving end into a LogRecord, use the
  275.     makeLogRecord function.
  276.     """
  277.     
  278.     def __init__(self, host, port):
  279.         """
  280.         Initializes the handler with a specific host address and port.
  281.  
  282.         The attribute 'closeOnError' is set to 1 - which means that if
  283.         a socket error occurs, the socket is silently closed and then
  284.         reopened on the next logging call.
  285.         """
  286.         logging.Handler.__init__(self)
  287.         self.host = host
  288.         self.port = port
  289.         self.sock = None
  290.         self.closeOnError = 0
  291.         self.retryTime = None
  292.         self.retryStart = 1.0
  293.         self.retryMax = 30.0
  294.         self.retryFactor = 2.0
  295.  
  296.     
  297.     def makeSocket(self):
  298.         '''
  299.         A factory method which allows subclasses to define the precise
  300.         type of socket they want.
  301.         '''
  302.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  303.         s.connect((self.host, self.port))
  304.         return s
  305.  
  306.     
  307.     def createSocket(self):
  308.         '''
  309.         Try to create a socket, using an exponential backoff with
  310.         a max retry time. Thanks to Robert Olson for the original patch
  311.         (SF #815911) which has been slightly refactored.
  312.         '''
  313.         now = time.time()
  314.         if self.retryTime is None:
  315.             attempt = 1
  316.         else:
  317.             attempt = now >= self.retryTime
  318.         if attempt:
  319.             
  320.             try:
  321.                 self.sock = self.makeSocket()
  322.                 self.retryTime = None
  323.             if self.retryTime is None:
  324.                 self.retryPeriod = self.retryStart
  325.             else:
  326.                 self.retryPeriod = self.retryPeriod * self.retryFactor
  327.                 if self.retryPeriod > self.retryMax:
  328.                     self.retryPeriod = self.retryMax
  329.                 
  330.  
  331.             self.retryTime = now + self.retryPeriod
  332.         
  333.         attempt
  334.  
  335.     
  336.     def send(self, s):
  337.         '''
  338.         Send a pickled string to the socket.
  339.  
  340.         This function allows for partial sends which can happen when the
  341.         network is busy.
  342.         '''
  343.         if self.sock is None:
  344.             self.createSocket()
  345.         
  346.         if self.sock:
  347.             
  348.             try:
  349.                 if hasattr(self.sock, 'sendall'):
  350.                     self.sock.sendall(s)
  351.                 else:
  352.                     sentsofar = 0
  353.                     left = len(s)
  354.                     while left > 0:
  355.                         sent = self.sock.send(s[sentsofar:])
  356.                         sentsofar = sentsofar + sent
  357.                         left = left - sent
  358.             except socket.error:
  359.                 self.sock.close()
  360.                 self.sock = None
  361.             except:
  362.                 None<EXCEPTION MATCH>socket.error
  363.             
  364.  
  365.         None<EXCEPTION MATCH>socket.error
  366.  
  367.     
  368.     def makePickle(self, record):
  369.         '''
  370.         Pickles the record in binary format with a length prefix, and
  371.         returns it ready for transmission across the socket.
  372.         '''
  373.         ei = record.exc_info
  374.         if ei:
  375.             dummy = self.format(record)
  376.             record.exc_info = None
  377.         
  378.         s = cPickle.dumps(record.__dict__, 1)
  379.         if ei:
  380.             record.exc_info = ei
  381.         
  382.         slen = struct.pack('>L', len(s))
  383.         return slen + s
  384.  
  385.     
  386.     def handleError(self, record):
  387.         '''
  388.         Handle an error during logging.
  389.  
  390.         An error has occurred during logging. Most likely cause -
  391.         connection lost. Close the socket so that we can retry on the
  392.         next event.
  393.         '''
  394.         if self.closeOnError and self.sock:
  395.             self.sock.close()
  396.             self.sock = None
  397.         else:
  398.             logging.Handler.handleError(self, record)
  399.  
  400.     
  401.     def emit(self, record):
  402.         '''
  403.         Emit a record.
  404.  
  405.         Pickles the record and writes it to the socket in binary format.
  406.         If there is an error with the socket, silently drop the packet.
  407.         If there was a problem with the socket, re-establishes the
  408.         socket.
  409.         '''
  410.         
  411.         try:
  412.             s = self.makePickle(record)
  413.             self.send(s)
  414.         except:
  415.             self.handleError(record)
  416.  
  417.  
  418.     
  419.     def close(self):
  420.         '''
  421.         Closes the socket.
  422.         '''
  423.         if self.sock:
  424.             self.sock.close()
  425.             self.sock = None
  426.         
  427.         logging.Handler.close(self)
  428.  
  429.  
  430.  
  431. class DatagramHandler(SocketHandler):
  432.     """
  433.     A handler class which writes logging records, in pickle format, to
  434.     a datagram socket.  The pickle which is sent is that of the LogRecord's
  435.     attribute dictionary (__dict__), so that the receiver does not need to
  436.     have the logging module installed in order to process the logging event.
  437.  
  438.     To unpickle the record at the receiving end into a LogRecord, use the
  439.     makeLogRecord function.
  440.  
  441.     """
  442.     
  443.     def __init__(self, host, port):
  444.         '''
  445.         Initializes the handler with a specific host address and port.
  446.         '''
  447.         SocketHandler.__init__(self, host, port)
  448.         self.closeOnError = 0
  449.  
  450.     
  451.     def makeSocket(self):
  452.         '''
  453.         The factory method of SocketHandler is here overridden to create
  454.         a UDP socket (SOCK_DGRAM).
  455.         '''
  456.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  457.         return s
  458.  
  459.     
  460.     def send(self, s):
  461.         '''
  462.         Send a pickled string to a socket.
  463.  
  464.         This function no longer allows for partial sends which can happen
  465.         when the network is busy - UDP does not guarantee delivery and
  466.         can deliver packets out of sequence.
  467.         '''
  468.         if self.sock is None:
  469.             self.createSocket()
  470.         
  471.         self.sock.sendto(s, (self.host, self.port))
  472.  
  473.  
  474.  
  475. class SysLogHandler(logging.Handler):
  476.     """
  477.     A handler class which sends formatted logging records to a syslog
  478.     server. Based on Sam Rushing's syslog module:
  479.     http://www.nightmare.com/squirl/python-ext/misc/syslog.py
  480.     Contributed by Nicolas Untz (after which minor refactoring changes
  481.     have been made).
  482.     """
  483.     LOG_EMERG = 0
  484.     LOG_ALERT = 1
  485.     LOG_CRIT = 2
  486.     LOG_ERR = 3
  487.     LOG_WARNING = 4
  488.     LOG_NOTICE = 5
  489.     LOG_INFO = 6
  490.     LOG_DEBUG = 7
  491.     LOG_KERN = 0
  492.     LOG_USER = 1
  493.     LOG_MAIL = 2
  494.     LOG_DAEMON = 3
  495.     LOG_AUTH = 4
  496.     LOG_SYSLOG = 5
  497.     LOG_LPR = 6
  498.     LOG_NEWS = 7
  499.     LOG_UUCP = 8
  500.     LOG_CRON = 9
  501.     LOG_AUTHPRIV = 10
  502.     LOG_LOCAL0 = 16
  503.     LOG_LOCAL1 = 17
  504.     LOG_LOCAL2 = 18
  505.     LOG_LOCAL3 = 19
  506.     LOG_LOCAL4 = 20
  507.     LOG_LOCAL5 = 21
  508.     LOG_LOCAL6 = 22
  509.     LOG_LOCAL7 = 23
  510.     priority_names = {
  511.         'alert': LOG_ALERT,
  512.         'crit': LOG_CRIT,
  513.         'critical': LOG_CRIT,
  514.         'debug': LOG_DEBUG,
  515.         'emerg': LOG_EMERG,
  516.         'err': LOG_ERR,
  517.         'error': LOG_ERR,
  518.         'info': LOG_INFO,
  519.         'notice': LOG_NOTICE,
  520.         'panic': LOG_EMERG,
  521.         'warn': LOG_WARNING,
  522.         'warning': LOG_WARNING }
  523.     facility_names = {
  524.         'auth': LOG_AUTH,
  525.         'authpriv': LOG_AUTHPRIV,
  526.         'cron': LOG_CRON,
  527.         'daemon': LOG_DAEMON,
  528.         'kern': LOG_KERN,
  529.         'lpr': LOG_LPR,
  530.         'mail': LOG_MAIL,
  531.         'news': LOG_NEWS,
  532.         'security': LOG_AUTH,
  533.         'syslog': LOG_SYSLOG,
  534.         'user': LOG_USER,
  535.         'uucp': LOG_UUCP,
  536.         'local0': LOG_LOCAL0,
  537.         'local1': LOG_LOCAL1,
  538.         'local2': LOG_LOCAL2,
  539.         'local3': LOG_LOCAL3,
  540.         'local4': LOG_LOCAL4,
  541.         'local5': LOG_LOCAL5,
  542.         'local6': LOG_LOCAL6,
  543.         'local7': LOG_LOCAL7 }
  544.     
  545.     def __init__(self, address = ('localhost', SYSLOG_UDP_PORT), facility = LOG_USER):
  546.         '''
  547.         Initialize a handler.
  548.  
  549.         If address is specified as a string, UNIX socket is used.
  550.         If facility is not specified, LOG_USER is used.
  551.         '''
  552.         logging.Handler.__init__(self)
  553.         self.address = address
  554.         self.facility = facility
  555.         if type(address) == types.StringType:
  556.             self._connect_unixsocket(address)
  557.             self.unixsocket = 1
  558.         else:
  559.             self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  560.             self.unixsocket = 0
  561.         self.formatter = None
  562.  
  563.     
  564.     def _connect_unixsocket(self, address):
  565.         self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
  566.         
  567.         try:
  568.             self.socket.connect(address)
  569.         except socket.error:
  570.             self.socket.close()
  571.             self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  572.  
  573.         self.socket.connect(address)
  574.  
  575.     log_format_string = '<%d>%s\x00'
  576.     
  577.     def encodePriority(self, facility, priority):
  578.         '''
  579.         Encode the facility and priority. You can pass in strings or
  580.         integers - if strings are passed, the facility_names and
  581.         priority_names mapping dictionaries are used to convert them to
  582.         integers.
  583.         '''
  584.         if type(facility) == types.StringType:
  585.             facility = self.facility_names[facility]
  586.         
  587.         if type(priority) == types.StringType:
  588.             priority = self.priority_names[priority]
  589.         
  590.         return facility << 3 | priority
  591.  
  592.     
  593.     def close(self):
  594.         '''
  595.         Closes the socket.
  596.         '''
  597.         if self.unixsocket:
  598.             self.socket.close()
  599.         
  600.         logging.Handler.close(self)
  601.  
  602.     
  603.     def emit(self, record):
  604.         '''
  605.         Emit a record.
  606.  
  607.         The record is formatted, and then sent to the syslog server. If
  608.         exception information is present, it is NOT sent to the server.
  609.         '''
  610.         msg = self.format(record)
  611.         msg = self.log_format_string % (self.encodePriority(self.facility, string.lower(record.levelname)), msg)
  612.         
  613.         try:
  614.             if self.unixsocket:
  615.                 
  616.                 try:
  617.                     self.socket.send(msg)
  618.                 except socket.error:
  619.                     self._connect_unixsocket(self.address)
  620.                     self.socket.send(msg)
  621.                 except:
  622.                     None<EXCEPTION MATCH>socket.error
  623.                 
  624.  
  625.             None<EXCEPTION MATCH>socket.error
  626.             self.socket.sendto(msg, self.address)
  627.         except:
  628.             self.handleError(record)
  629.  
  630.  
  631.  
  632.  
  633. class SMTPHandler(logging.Handler):
  634.     '''
  635.     A handler class which sends an SMTP email for each logging event.
  636.     '''
  637.     
  638.     def __init__(self, mailhost, fromaddr, toaddrs, subject):
  639.         '''
  640.         Initialize the handler.
  641.  
  642.         Initialize the instance with the from and to addresses and subject
  643.         line of the email. To specify a non-standard SMTP port, use the
  644.         (host, port) tuple format for the mailhost argument.
  645.         '''
  646.         logging.Handler.__init__(self)
  647.         if type(mailhost) == types.TupleType:
  648.             (host, port) = mailhost
  649.             self.mailhost = host
  650.             self.mailport = port
  651.         else:
  652.             self.mailhost = mailhost
  653.             self.mailport = None
  654.         self.fromaddr = fromaddr
  655.         if type(toaddrs) == types.StringType:
  656.             toaddrs = [
  657.                 toaddrs]
  658.         
  659.         self.toaddrs = toaddrs
  660.         self.subject = subject
  661.  
  662.     
  663.     def getSubject(self, record):
  664.         '''
  665.         Determine the subject for the email.
  666.  
  667.         If you want to specify a subject line which is record-dependent,
  668.         override this method.
  669.         '''
  670.         return self.subject
  671.  
  672.     weekdayname = [
  673.         'Mon',
  674.         'Tue',
  675.         'Wed',
  676.         'Thu',
  677.         'Fri',
  678.         'Sat',
  679.         'Sun']
  680.     monthname = [
  681.         None,
  682.         'Jan',
  683.         'Feb',
  684.         'Mar',
  685.         'Apr',
  686.         'May',
  687.         'Jun',
  688.         'Jul',
  689.         'Aug',
  690.         'Sep',
  691.         'Oct',
  692.         'Nov',
  693.         'Dec']
  694.     
  695.     def date_time(self):
  696.         '''
  697.         Return the current date and time formatted for a MIME header.
  698.         Needed for Python 1.5.2 (no email package available)
  699.         '''
  700.         (year, month, day, hh, mm, ss, wd, y, z) = time.gmtime(time.time())
  701.         s = '%s, %02d %3s %4d %02d:%02d:%02d GMT' % (self.weekdayname[wd], day, self.monthname[month], year, hh, mm, ss)
  702.         return s
  703.  
  704.     
  705.     def emit(self, record):
  706.         '''
  707.         Emit a record.
  708.  
  709.         Format the record and send it to the specified addressees.
  710.         '''
  711.         
  712.         try:
  713.             import smtplib
  714.             
  715.             try:
  716.                 formatdate = formatdate
  717.                 import email.Utils
  718.             except:
  719.                 formatdate = self.date_time
  720.  
  721.             port = self.mailport
  722.             if not port:
  723.                 port = smtplib.SMTP_PORT
  724.             
  725.             smtp = smtplib.SMTP(self.mailhost, port)
  726.             msg = self.format(record)
  727.             msg = 'From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s' % (self.fromaddr, string.join(self.toaddrs, ','), self.getSubject(record), formatdate(), msg)
  728.             smtp.sendmail(self.fromaddr, self.toaddrs, msg)
  729.             smtp.quit()
  730.         except:
  731.             self.handleError(record)
  732.  
  733.  
  734.  
  735.  
  736. class NTEventLogHandler(logging.Handler):
  737.     '''
  738.     A handler class which sends events to the NT Event Log. Adds a
  739.     registry entry for the specified application name. If no dllname is
  740.     provided, win32service.pyd (which contains some basic message
  741.     placeholders) is used. Note that use of these placeholders will make
  742.     your event logs big, as the entire message source is held in the log.
  743.     If you want slimmer logs, you have to pass in the name of your own DLL
  744.     which contains the message definitions you want to use in the event log.
  745.     '''
  746.     
  747.     def __init__(self, appname, dllname = None, logtype = 'Application'):
  748.         logging.Handler.__init__(self)
  749.         
  750.         try:
  751.             import win32evtlogutil
  752.             import win32evtlog
  753.             self.appname = appname
  754.             self._welu = win32evtlogutil
  755.             if not dllname:
  756.                 dllname = os.path.split(self._welu.__file__)
  757.                 dllname = os.path.split(dllname[0])
  758.                 dllname = os.path.join(dllname[0], 'win32service.pyd')
  759.             
  760.             self.dllname = dllname
  761.             self.logtype = logtype
  762.             self._welu.AddSourceToRegistry(appname, dllname, logtype)
  763.             self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
  764.             self.typemap = {
  765.                 logging.DEBUG: win32evtlog.EVENTLOG_INFORMATION_TYPE,
  766.                 logging.INFO: win32evtlog.EVENTLOG_INFORMATION_TYPE,
  767.                 logging.WARNING: win32evtlog.EVENTLOG_WARNING_TYPE,
  768.                 logging.ERROR: win32evtlog.EVENTLOG_ERROR_TYPE,
  769.                 logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE }
  770.         except ImportError:
  771.             print 'The Python Win32 extensions for NT (service, event logging) appear not to be available.'
  772.             self._welu = None
  773.  
  774.  
  775.     
  776.     def getMessageID(self, record):
  777.         '''
  778.         Return the message ID for the event record. If you are using your
  779.         own messages, you could do this by having the msg passed to the
  780.         logger being an ID rather than a formatting string. Then, in here,
  781.         you could use a dictionary lookup to get the message ID. This
  782.         version returns 1, which is the base message ID in win32service.pyd.
  783.         '''
  784.         return 1
  785.  
  786.     
  787.     def getEventCategory(self, record):
  788.         '''
  789.         Return the event category for the record.
  790.  
  791.         Override this if you want to specify your own categories. This version
  792.         returns 0.
  793.         '''
  794.         return 0
  795.  
  796.     
  797.     def getEventType(self, record):
  798.         """
  799.         Return the event type for the record.
  800.  
  801.         Override this if you want to specify your own types. This version does
  802.         a mapping using the handler's typemap attribute, which is set up in
  803.         __init__() to a dictionary which contains mappings for DEBUG, INFO,
  804.         WARNING, ERROR and CRITICAL. If you are using your own levels you will
  805.         either need to override this method or place a suitable dictionary in
  806.         the handler's typemap attribute.
  807.         """
  808.         return self.typemap.get(record.levelno, self.deftype)
  809.  
  810.     
  811.     def emit(self, record):
  812.         '''
  813.         Emit a record.
  814.  
  815.         Determine the message ID, event category and event type. Then
  816.         log the message in the NT event log.
  817.         '''
  818.         if self._welu:
  819.             
  820.             try:
  821.                 id = self.getMessageID(record)
  822.                 cat = self.getEventCategory(record)
  823.                 type = self.getEventType(record)
  824.                 msg = self.format(record)
  825.                 self._welu.ReportEvent(self.appname, id, cat, type, [
  826.                     msg])
  827.             self.handleError(record)
  828.  
  829.         
  830.  
  831.     
  832.     def close(self):
  833.         '''
  834.         Clean up this handler.
  835.  
  836.         You can remove the application name from the registry as a
  837.         source of event log entries. However, if you do this, you will
  838.         not be able to see the events as you intended in the Event Log
  839.         Viewer - it needs to be able to access the registry to get the
  840.         DLL name.
  841.         '''
  842.         logging.Handler.close(self)
  843.  
  844.  
  845.  
  846. class HTTPHandler(logging.Handler):
  847.     '''
  848.     A class which sends records to a Web server, using either GET or
  849.     POST semantics.
  850.     '''
  851.     
  852.     def __init__(self, host, url, method = 'GET'):
  853.         '''
  854.         Initialize the instance with the host, the request URL, and the method
  855.         ("GET" or "POST")
  856.         '''
  857.         logging.Handler.__init__(self)
  858.         method = string.upper(method)
  859.         if method not in [
  860.             'GET',
  861.             'POST']:
  862.             raise ValueError, 'method must be GET or POST'
  863.         
  864.         self.host = host
  865.         self.url = url
  866.         self.method = method
  867.  
  868.     
  869.     def mapLogRecord(self, record):
  870.         '''
  871.         Default implementation of mapping the log record into a dict
  872.         that is sent as the CGI data. Overwrite in your class.
  873.         Contributed by Franz  Glasner.
  874.         '''
  875.         return record.__dict__
  876.  
  877.     
  878.     def emit(self, record):
  879.         '''
  880.         Emit a record.
  881.  
  882.         Send the record to the Web server as an URL-encoded dictionary
  883.         '''
  884.         
  885.         try:
  886.             import httplib
  887.             import urllib
  888.             h = httplib.HTTP(self.host)
  889.             url = self.url
  890.             data = urllib.urlencode(self.mapLogRecord(record))
  891.             if self.method == 'GET':
  892.                 if string.find(url, '?') >= 0:
  893.                     sep = '&'
  894.                 else:
  895.                     sep = '?'
  896.                 url = url + '%c%s' % (sep, data)
  897.             
  898.             h.putrequest(self.method, url)
  899.             if self.method == 'POST':
  900.                 h.putheader('Content-length', str(len(data)))
  901.             
  902.             h.endheaders()
  903.             if self.method == 'POST':
  904.                 h.send(data)
  905.             
  906.             h.getreply()
  907.         except:
  908.             self.handleError(record)
  909.  
  910.  
  911.  
  912.  
  913. class BufferingHandler(logging.Handler):
  914.     """
  915.   A handler class which buffers logging records in memory. Whenever each
  916.   record is added to the buffer, a check is made to see if the buffer should
  917.   be flushed. If it should, then flush() is expected to do what's needed.
  918.     """
  919.     
  920.     def __init__(self, capacity):
  921.         '''
  922.         Initialize the handler with the buffer size.
  923.         '''
  924.         logging.Handler.__init__(self)
  925.         self.capacity = capacity
  926.         self.buffer = []
  927.  
  928.     
  929.     def shouldFlush(self, record):
  930.         '''
  931.         Should the handler flush its buffer?
  932.  
  933.         Returns true if the buffer is up to capacity. This method can be
  934.         overridden to implement custom flushing strategies.
  935.         '''
  936.         return len(self.buffer) >= self.capacity
  937.  
  938.     
  939.     def emit(self, record):
  940.         '''
  941.         Emit a record.
  942.  
  943.         Append the record. If shouldFlush() tells us to, call flush() to process
  944.         the buffer.
  945.         '''
  946.         self.buffer.append(record)
  947.         if self.shouldFlush(record):
  948.             self.flush()
  949.         
  950.  
  951.     
  952.     def flush(self):
  953.         '''
  954.         Override to implement custom flushing behaviour.
  955.  
  956.         This version just zaps the buffer to empty.
  957.         '''
  958.         self.buffer = []
  959.  
  960.     
  961.     def close(self):
  962.         """
  963.         Close the handler.
  964.  
  965.         This version just flushes and chains to the parent class' close().
  966.         """
  967.         self.flush()
  968.         logging.Handler.close(self)
  969.  
  970.  
  971.  
  972. class MemoryHandler(BufferingHandler):
  973.     '''
  974.     A handler class which buffers logging records in memory, periodically
  975.     flushing them to a target handler. Flushing occurs whenever the buffer
  976.     is full, or when an event of a certain severity or greater is seen.
  977.     '''
  978.     
  979.     def __init__(self, capacity, flushLevel = logging.ERROR, target = None):
  980.         '''
  981.         Initialize the handler with the buffer size, the level at which
  982.         flushing should occur and an optional target.
  983.  
  984.         Note that without a target being set either here or via setTarget(),
  985.         a MemoryHandler is no use to anyone!
  986.         '''
  987.         BufferingHandler.__init__(self, capacity)
  988.         self.flushLevel = flushLevel
  989.         self.target = target
  990.  
  991.     
  992.     def shouldFlush(self, record):
  993.         '''
  994.         Check for buffer full or a record at the flushLevel or higher.
  995.         '''
  996.         if not len(self.buffer) >= self.capacity:
  997.             pass
  998.         return record.levelno >= self.flushLevel
  999.  
  1000.     
  1001.     def setTarget(self, target):
  1002.         '''
  1003.         Set the target handler for this handler.
  1004.         '''
  1005.         self.target = target
  1006.  
  1007.     
  1008.     def flush(self):
  1009.         '''
  1010.         For a MemoryHandler, flushing means just sending the buffered
  1011.         records to the target, if there is one. Override if you want
  1012.         different behaviour.
  1013.         '''
  1014.         if self.target:
  1015.             for record in self.buffer:
  1016.                 self.target.handle(record)
  1017.             
  1018.             self.buffer = []
  1019.         
  1020.  
  1021.     
  1022.     def close(self):
  1023.         '''
  1024.         Flush, set the target to None and lose the buffer.
  1025.         '''
  1026.         self.flush()
  1027.         self.target = None
  1028.         BufferingHandler.close(self)
  1029.  
  1030.  
  1031.